import java.util.*;
/**
 * 合并两个有序链表
 * 将两个升序链表合并为一个新的升序链表并返回
 */
public class mergeTwoLists {
    /**
     * 链表节点类
     * 包含节点值和指向下一个节点的引用
     */
    public static class ListNode{
        int val;        // 节点值
        ListNode next;  // 指向下一个节点的引用
        
        // 无参构造函数
        ListNode(){}
        
        // 带值的构造函数
        ListNode(int val){
            this.val = val;
        }
        
        // 带值和下一个节点的构造函数
        ListNode(int val, ListNode next){
            this.val = val;
            this.next = next;
        }
    }

    /**
     * 合并两个有序链表的方法
     * @param l1 第一个有序链表
     * @param l2 第二个有序链表
     * @return 合并后的新链表
     */
    public static ListNode mergeTwoListsM(ListNode l1, ListNode l2){
        // 创建虚拟头节点，用于简化操作
        ListNode head = new ListNode(0);
        // 保存头节点的引用，用于最后返回结果
        ListNode dummy = head;
        
        // 当两个链表都不为空时，比较节点值并合并
        while(l1 != null && l2 != null){
            int x = l1.val;
            int y = l2.val;
            
            // 比较两个链表当前节点的值，将较小的值添加到新链表中
            if(x > y){
                // 如果l2的节点值较小，创建新节点并连接到结果链表
                ListNode newNode = new ListNode(y);
                head.next = newNode;
                head = head.next;
                l2 = l2.next;  // l2指针后移
            }else{
                // 如果l1的节点值较小或相等，创建新节点并连接到结果链表
                ListNode newNode = new ListNode(x);
                head.next = newNode;
                head = head.next;
                l1 = l1.next;  // l1指针后移
            }
        }
        
        // 处理剩余节点
        // 如果l1还有剩余节点，直接连接到结果链表
        if(l1 != null){
            head.next = l1;
        }
        // 如果l2还有剩余节点，直接连接到结果链表
        if(l2 != null){
            head.next = l2;
        }
        
        // 返回合并后的链表（跳过虚拟头节点）
        return dummy.next;
    }

    /**
     * 主函数：处理输入输出
     * 从控制台读取两个有序链表，合并后输出结果
     */
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        
        // 读取第一个链表
        String[] s1 = sc.nextLine().split(" ");
        ListNode l1 = new ListNode(Integer.parseInt(s1[0]));
        ListNode now = l1;
        // 构建第一个链表
        for(int i = 1; i < s1.length; i++){
            ListNode newNode = new ListNode(Integer.parseInt(s1[i]));
            now.next = newNode;
            now = now.next;
        }
        
        // 读取第二个链表
        String[] s2 = sc.nextLine().split(" ");
        ListNode l2 = new ListNode(Integer.parseInt(s2[0]));
        now = l2;
        // 构建第二个链表
        for(int i = 1; i < s2.length; i++){
            ListNode newNode = new ListNode(Integer.parseInt(s2[i]));
            now.next = newNode;
            now = now.next;
        }
        
        // 合并链表并输出结果
        ListNode result = mergeTwoListsM(l1, l2);
        while(result != null){
            System.out.print(result.val + " ");
            result = result.next;
        }
        sc.close();
    }
}
